/* -*-jde-*- */
package ui.alumnoInterfaz;

import java.sql.SQLException;
import ui.empresaInterfaz.VacanteBean;
import app.alumnoe.AlumnoE;
import app.alumnoe.Busqueda;
import app.alumnoe.catalogos.beans.Carrera;
import app.alumnoe.catalogos.Carreras;
import app.alumnoe.catalogos.beans.UltimoGrado;
import app.alumnoe.catalogos.UltimosGrados;
import app.alumnoe.cv.CV;
import app.alumnoe.cv.ExperienciasProfesionales;
import app.alumnoe.cv.Formaciones;
import app.alumnoe.cv.Idiomas;
import app.alumnoe.cv.Investigaciones;
import app.alumnoe.cv.TecnicosProfesionales;
import app.alumnoe.cv.beans.ExperienciaProfesional;
import app.alumnoe.cv.beans.Formacion;
import app.alumnoe.cv.beans.Idioma;
import app.alumnoe.cv.beans.Investigacion;
import app.alumnoe.cv.beans.TecnicoProfesional;
import app.conexion.Conexion;
import app.conexion.ConexionException;
import app.empresa.Postulados;
import app.empresa.Vacante;
import app.htmlGenerator.HTMLCVGenerator;
import app.usuario.Correos;
import app.usuario.Telefonos;
import app.usuario.Usuario;
import app.usuario.beans.Correo;
import app.usuario.beans.Telefono;
import app.util.Fecha;
import app.util.appException;
import java.sql.ResultSet;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;
import javax.faces.context.FacesContext;
import javax.faces.model.SelectItem;

/**
 * Este Managed Bean sirve para emular las actividades de un alumno. Extiende de
 * una Bean llamado AlumnoBean que tiene la definición de todos los objetos que
 * puede tener un alumno así como sus métodos de acceso
 *
 * @author Victor Miguel Peralta Santa Anna
 * @since Enero 2012
 * @version 0.1
 */
@ManagedBean(name = "alumnoActionListener")
@SessionScoped
public class AlumnoActionListener extends AlumnoBean {

    /**
     * Creates a new instance of AlumnoActionListener
     */
    public AlumnoActionListener() {
        try {
            //Catalogo de porcentajes de termino de carrera
            if (porcentajeCatalogo.isEmpty()) {
                porcentajeCatalogo.add(new SelectItem("50%-60%", "50%-60%"));
                porcentajeCatalogo.add(new SelectItem("60%-70%", "60%-70%"));
                porcentajeCatalogo.add(new SelectItem("70%-80%", "70%-80%"));
                porcentajeCatalogo.add(new SelectItem("80%-90%", "80%-90%"));
                porcentajeCatalogo.add(new SelectItem("90%-100%", "90%-100%"));
            }
            //Catalogo de carreras guardados en la base de datos
            //Conexion con = new Conexion();
            Carreras carreraClass = new Carreras();
            LinkedList<Carrera> carreras = carreraClass.getCarreras();

            UltimosGrados ultGrad = new UltimosGrados();
            LinkedList<UltimoGrado> grados = ultGrad.getUltimosGrados();

            //Catalogo de las carreras
            if (carreraCatalogo.isEmpty()) {
                for (Carrera c : carreras) {
                    carreraCatalogo.add(new SelectItem(c.getId(), c.getCarrera()));
                }
            }

            //Catalogo ultimo Grado Académico
            if (ultimoGradoCatalogo.isEmpty()) {
                for (UltimoGrado g : grados) {
                    ultimoGradoCatalogo.add(new SelectItem(g.getId(), g.getGrado()));
                }
            }

            //Obtenemos de sessión el objeto creado por el Managed Bean de login
            AlumnoBean alumno = (AlumnoBean) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("alumnoBean");

            //Llenamos en el bean local las propiedades guardadas en el bean de sesión
            this.setNombre(alumno.getNombre());
            this.setAlumnoId(alumno.getAlumnoId());
            this.setApMat(alumno.getApMat());
            this.setApPat(alumno.getApPat());
            this.setAreasInteres(alumno.getAreasInteres());
            this.setCarrera(String.valueOf(alumno.getCarreraId()));
            this.setCarreraId(alumno.getCarreraId());
            this.setCorreo(alumno.getCorreo());
            this.setCorreo2(alumno.getCorreo2());
            this.setCvId(alumno.getCvId());
            this.setDispuestoReubicarse(alumno.getDispuestoReubicarse());
            this.setDispuestoViajar(alumno.getDispuestoViajar());
            this.setDomicilio(alumno.getDomicilio());
            this.setEstudianteEgresado(alumno.getEstudianteEgresado());
            this.setExpProfesionales(alumno.getExpProfesionales());
            this.setFechaActualizacion(alumno.getFechaActualizacion());
            this.setFechaGrad(alumno.getFechaGrad());
            this.setFechaNac(alumno.getFechaNac());
            this.setFormaciones(alumno.getFormaciones());
            this.setHabilidadesTecProf(alumno.getHabilidadesTecProf());
            this.setIdiomas(alumno.getIdiomas());
            this.setInvestigaciones(alumno.getInvestigaciones());
            this.setNumeroCta(alumno.getNumeroCta());
            this.setObjetivo(alumno.getObjetivo());
            this.setPorcentajeCreditos(alumno.getPorcentajeCreditos());
            this.setTelefono(alumno.getTelefono());
            this.setTelefono2(alumno.getTelefono2());
            this.setUltimoGrado(alumno.getUltimoGrado());
            this.setMisPostulaciones(alumno.getMisPostulaciones());



            //con.close();

        } catch (appException ex) {
            Logger.getLogger(AlumnoActionListener.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public String generarCV() {
        try {
            //Conexion con = new Conexion();
            AlumnoE alumno = new AlumnoE(getAlumnoId());

            String html = alumno.generaHTML();

            this.setHtmlElegido(html);

            alumno.activaAlumno();

            //con.close();
            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO,
                    "Se actualizó el CV en línea.",
                    "Puede ver su CV generado en la sección correspondiente"));

        } catch (appException ex) {
            Logger.getLogger(AlumnoActionListener.class.getName()).log(Level.SEVERE, null, ex);
            //con.close();
            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_ERROR,
                    "Error al generar el CV.",
                    "No pudo ser actualizado el CV."));
        }

        return "";
    }

    /**
     * Guarda los cambios del perfil. Este método sirve para guardar los
     * componentes de la forma en la base de datos
     *
     * @return
     */
    public String guardarCambiosPerfil() {
        try {

            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO,
                    "Se guardará la información. ",
                    "En proceso ..."));
            //Conexion con = new Conexion();
            AlumnoE alumnoBd = new AlumnoE(this.getAlumnoId());
            //Lo que recibimos de la página es el código por lo que hay que 
            //poner el codigo directamente y luego hacer el mapeo
            alumnoBd.setnCarreras(Integer.valueOf(this.getCarrera()));
            alumnoBd.setnUltimoGrado(Integer.valueOf(this.getUltimoGrado()));

            //Hacemos el mapeo de los comboboxes
            this.setCarrera(getCarrera());
            this.setUltimoGrado(getUltimoGrado());
            alumnoBd.setScarrera(this.getCarrera());
            alumnoBd.setSgrado(this.getUltimoGrado());

            if (getEstudianteEgresado().compareTo("Alumno") == 0) {
                alumnoBd.setbEstudianteEgresado(true);
            } else {
                alumnoBd.setbEstudianteEgresado(false);
            }
            alumnoBd.setsApellidoMaterno(getApMat());
            alumnoBd.setsApellidoPaterno(getApPat());
            alumnoBd.setsNombre(getNombre());
            alumnoBd.setsNumeroCuenta(getNumeroCta());

            Calendar cal = Calendar.getInstance();
            cal.setTime(getFechaNac());
            int day = cal.get(Calendar.DATE);
            int month = cal.get(Calendar.MONTH) + 1;
            int year = cal.get(Calendar.YEAR);
            alumnoBd.setdFechaNacimiento(new Fecha(year, month, day));

            alumnoBd.save();
            //Obtener correos y cv de la sesion
            CV mycv = (CV) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("cvBD");

            //Llenamos la fecha de graduación
            if (getFechaGrad() != null) {
                Calendar fgradCal = Calendar.getInstance();
                fgradCal.setTime(getFechaGrad());
                day = fgradCal.get(Calendar.DATE);
                month = fgradCal.get(Calendar.MONTH) + 1;
                year = fgradCal.get(Calendar.YEAR);
                mycv.setdFechaFinalCarrera(new Fecha(year, month, day));
            }
            //Llenar Correos  
            Correos correoClass = new Correos(getAlumnoId());
            LinkedList<Correo> correosdb = correoClass.getCorreos();
            correosdb.get(0).setsCorreo(getCorreo());
            correosdb.get(0).save();
            if (correosdb.size() == 2) {
                correosdb.get(1).setsCorreo(getCorreo2());
                correosdb.get(1).save();
            } else {
                Correo c2 = new Correo(-1, getAlumnoId(), getCorreo2());
                c2.save();
            }

            //Llenar telefonos
            Telefonos telClass = new Telefonos(getAlumnoId());
            LinkedList<Telefono> telefonosBD = telClass.getTelefonos();
            telefonosBD.get(0).setsTelefono(getTelefono());
            telefonosBD.get(0).save();
            if (telefonosBD.size() == 2) {
                telefonosBD.get(1).setsTelefono(getTelefono2());
                telefonosBD.get(1).save();
            } else {
                Telefono a = new Telefono(-1, getAlumnoId(), getTelefono2());
                a.save();
            }

            //Llenar Parte del CV
            mycv.setsCreditos(getPorcentajeCreditos());
            mycv.setsObjetivo(getObjetivo());
            mycv.setsAreasInteres(getAreasInteres());

            if (getDispuestoViajar().compareTo("0") == 0) {
                mycv.setbDispuestoAViajar(true);
            } else {
                mycv.setbDispuestoAViajar(false);
            }

            if (getDispuestoReubicarse().compareTo("0") == 0) {
                mycv.setbDispuestoAReubicarse(true);
            } else {
                mycv.setbDispuestoAReubicarse(false);
            }

            mycv.saveAll();
            //con.close();

            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO,
                    "Éxito.",
                    "Su información se encuentra al día."));

            return "/Alumno/AlumnoCurriculum?faces-redirect=true";
        } catch (appException ex) {
            Logger.getLogger(AlumnoActionListener.class.getName()).log(Level.SEVERE, null, ex);
            return "";
        }
    }

    /**
     * Guarda los cambios en las experiencias profesionales Crear, Actualizar y
     * Borrar
     *
     * @return
     */
    public String guardarExpProf() {
        try {

            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO,
                    "Se guardarán las experiencias profesionales de acuerdo a su información. ",
                    "En proceso ..."));
            //Conexion con = new Conexion();
            ExperienciasProfesionales expProfClass = new ExperienciasProfesionales(getAlumnoId());
            LinkedList<ExperienciaProfesional> expprofDB = expProfClass.getExperienciasprofesionales();

            //Para cada experiencia profesional en la página web                        
            for (experienciaProf exp : this.getExpProfesionales()) {
                boolean pActual;
                if (exp.getPuestoActual().compareTo("0") == 0) {
                    pActual = true;
                } else {
                    pActual = false;
                }
                Calendar cal = Calendar.getInstance();
                cal.setTime(exp.getFechaIngreso());
                int day = cal.get(Calendar.DATE);
                int month = cal.get(Calendar.MONTH) + 1;
                int year = cal.get(Calendar.YEAR);
                Fecha entrada = new Fecha(year, month, day);
                Fecha salida = null;
                if (exp.getFechaSalida() != null) {
                    cal.setTime(exp.getFechaSalida());
                    year = cal.get(Calendar.YEAR);
                    month = cal.get(Calendar.MONTH) + 1;
                    day = cal.get(Calendar.DATE);
                    salida = new Fecha(year, month, day);
                }

                //Registrar nuevas experiencias profesionales
                if (exp.getIdExpProf().compareTo("-1") == 0) {
                    ExperienciaProfesional f = new ExperienciaProfesional(
                            -1, getCvId(), exp.getEmpresa(), exp.getGiro(), exp.getPuesto(),
                            entrada, salida, pActual, exp.getFunciones());
                    f.save();
                    exp.setIdExpProf(String.valueOf(f.getnIdExperienciaProfesional()));
                } else { //Actualizar experiencias existentes
                    for (ExperienciaProfesional expBD : expprofDB) {
                        if (Integer.valueOf(exp.getIdExpProf()) == expBD.getnIdExperienciaProfesional()) {
                            expBD.setbPuestoActual(pActual);
                            expBD.setdFechaIngreso(entrada);
                            expBD.setdFechaSalida(salida);
                            expBD.setsEmpresa(exp.getEmpresa());
                            expBD.setsFunciones(exp.getFunciones());
                            expBD.setsGiro(exp.getGiro());
                            expBD.setsPuesto(exp.getPuesto());
                            expBD.save();
                        }
                    }
                }
            }
            //Borrar las experiencias que no estan en la página pero si en la base
            for (ExperienciaProfesional expbd : expprofDB) {
                boolean seDebeBorrar = true;
                for (experienciaProf exp : this.getExpProfesionales()) {
                    if (expbd.getnIdExperienciaProfesional() == Integer.valueOf(exp.getIdExpProf())) {
                        seDebeBorrar = false;
                    }
                }
                if (seDebeBorrar) {
                    expbd.delete();
                }
            }
            //f.delete();

            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO,
                    "Éxito.",
                    "Su información se encuentra al día."));

            //con.close();
            return "";
        } catch (appException ex) {
            Logger.getLogger(AlumnoActionListener.class.getName()).log(Level.SEVERE, null, ex);
            return "";
        }
    }

    /**
     * Guarda los cambios en los Idiomas Crear, Actualizar y Borrar
     *
     * @return
     */
    public String guardarIdiomas() {
        try {
            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO,
                    "Se guardaran los idiomas de acuerdo a su información. ",
                    "En proceso ..."));
            //Conexion con = new Conexion();
            Idiomas idiomasClass = new Idiomas(getCvId());
            LinkedList<Idioma> idiomasbd = idiomasClass.getIdiomas();
            for (idiomaBean idiom : getIdiomas()) {
                boolean compLec = false;
                if (idiom.getCompresionLec().compareTo("0") == 0) {
                    compLec = true;
                }

                if (idiom.getIdiomaId().compareTo("-1") == 0) {
                    //Debemos generar un nuevo idioma
                    Idioma f = new Idioma(-1, getCvId(), idiom.getIdioma(), compLec, idiom.getNivel(), idiom.getInstitucion());
                    f.save();
                    idiom.setIdiomaId(String.valueOf(f.getnIdIdioma()));
                } else {
                    //Debemos hacer una actualización
                    for (Idioma idiomaBD : idiomasbd) {
                        if (idiomaBD.getnIdIdioma() == Integer.valueOf(
                                idiom.getIdiomaId())) {
                            idiomaBD.setComprensionLectura(compLec);
                            idiomaBD.setsIdioma(idiom.getIdioma());
                            idiomaBD.setsInstitucionEducativa(idiom.getInstitucion());
                            idiomaBD.setsNivel(idiom.getNivel());
                            idiomaBD.save();
                        }
                    }
                }
            }

            //Borrar los idiomas que no están en la página pero si en la base
            for (Idioma idbd : idiomasbd) {
                boolean seDebeBorrar = true;
                for (idiomaBean idiom : getIdiomas()) {
                    if (Integer.valueOf(idiom.getIdiomaId()) == idbd.getnIdIdioma()) {
                        seDebeBorrar = false;
                    }
                }
                if (seDebeBorrar) {
                    idbd.delete();
                }
            }

            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO,
                    "Éxito.",
                    "Su información se encuentra al día."));
            //con.close();
            return "";
        } catch (appException ex) {
            Logger.getLogger(AlumnoActionListener.class.getName()).log(Level.SEVERE, null, ex);
            return "";
        }
    }

    /**
     * Guarda los cambios en las habilidades tecnico profesionales Crear,
     * Actualizar y Borrar
     *
     * @return
     */
    public String guardarHabTec() {
        try {
            //Conexion con = new Conexion();

            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO,
                    "Se guardarán las habilidades técnicas de acuerdo a su información. ",
                    "En proceso ..."));

            TecnicosProfesionales tcClass = new TecnicosProfesionales(getAlumnoId());
            LinkedList<TecnicoProfesional> tecprofsBD = tcClass.getTecnicosProfesionales();
            for (tecnicoProfBean tecProfInterfaz : getHabilidadesTecProf()) {
                if (tecProfInterfaz.getIdTecProf().compareTo("-1") == 0) {
                    //Creamos una nueva habilidad
                    TecnicoProfesional f = new TecnicoProfesional(-1, getCvId(), tecProfInterfaz.getConocimiento(), tecProfInterfaz.getNivel(),
                            tecProfInterfaz.getAnosExperiencia(), tecProfInterfaz.getComentario());
                    f.save();
                    //actualizamos el identifiacador de la actividad en la interfaz
                    tecProfInterfaz.setIdTecProf(String.valueOf(f.getnIdTecnicoProfesionales()));
                } else {
                    //Actualizamos los datos
                    for (TecnicoProfesional tecBD : tecprofsBD) {
                        if (tecBD.getnIdTecnicoProfesionales() == Integer.valueOf(tecProfInterfaz.getIdTecProf())) {
                            tecBD.setsAniosExperiencia(tecProfInterfaz.getAnosExperiencia());
                            tecBD.setsComentarios(tecProfInterfaz.getComentario());
                            tecBD.setsNivel(tecProfInterfaz.getNivel());
                            tecBD.setsNombreConocimiento(tecProfInterfaz.getConocimiento());
                            tecBD.save();
                        }
                    }
                }
            }
            //Borrar habilidades que no estan en la interfaz pero si en la base
            for (TecnicoProfesional tecbd : tecprofsBD) {
                boolean seDebeBorrar = true;
                for (tecnicoProfBean tIterf : getHabilidadesTecProf()) {
                    if (Integer.valueOf(tIterf.getIdTecProf()) == tecbd.getnIdTecnicoProfesionales()) {
                        seDebeBorrar = false;
                    }
                }
                if (seDebeBorrar) {
                    tecbd.delete();
                }
            }

            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO,
                    "Éxito.",
                    "Su información se encuentra al día."));
            //con.close();
            return "";
        } catch (appException ex) {
            Logger.getLogger(AlumnoActionListener.class.getName()).log(Level.SEVERE, null, ex);
            return "";
        }
    }

    /**
     * Guarda los cambios en la formación académica Crear, Actualizar y Borrar
     *
     * @return
     */
    public String guardarFormacion() {
        try {
            //Conexion con = new Conexion();
            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO,
                    "Se guardará su formación profesional de acuerdo a su información. ",
                    "En proceso ..."));

            Formaciones formClass = new Formaciones(getAlumnoId());
            LinkedList<Formacion> formacionesBD = formClass.getFormaciones();
            for (formacionBean formInterfaz : getFormaciones()) {
                //Preparamos las fechas
                Calendar cal = Calendar.getInstance();
                cal.setTime(formInterfaz.getFechaInicio());
                int day = cal.get(Calendar.DATE);
                int month = cal.get(Calendar.MONTH) + 1;
                int year = cal.get(Calendar.YEAR);
                Fecha inicio = new Fecha(year, month, day);
                Fecha termino = null;

                if (formInterfaz.getFechafin() != null) {
                    cal.setTime(formInterfaz.getFechafin());
                    day = cal.get(Calendar.DATE);
                    month = cal.get(Calendar.MONTH) + 1;
                    year = cal.get(Calendar.YEAR);
                    termino = new Fecha(year, month, day);
                }


                // AQUI HABíA UN ERROR DE ALUMNO ID Y ERA CV ID.
                if (formInterfaz.getFormacionId().compareTo("-1") == 0) {
                    Formacion f = new Formacion(-1, getCvId(), formInterfaz.getTitulo(),
                            formInterfaz.getInstitucion(), inicio, termino, formInterfaz.getPromedio(),
                            formInterfaz.getDescripcion());
                    f.save();
                } else {//Actualizamos la entrada existente
                    for (Formacion fBD : formacionesBD) {
                        if (fBD.getIdFormacion() == Integer.valueOf(formInterfaz.getFormacionId())) {
                            //convertimos la fecha inicial
                            cal.setTime(formInterfaz.getFechaInicio());
                            day = cal.get(Calendar.DATE);
                            month = cal.get(Calendar.MONTH) + 1;
                            year = cal.get(Calendar.YEAR);
                            fBD.setdFechaInicio(new Fecha(year, month, day));

                            //convertimos la fecha final
                            if (formInterfaz.getFechafin() != null) {
                                cal.setTime(formInterfaz.getFechafin());
                                day = cal.get(Calendar.DATE);
                                month = cal.get(Calendar.MONTH) + 1;
                                year = cal.get(Calendar.YEAR);
                                fBD.setdFechaFin(new Fecha(year, month, day));
                            } else {
                                fBD.setdFechaFin(null);
                            }

                            //El resto de los atributos
                            fBD.setsDescripcion(formInterfaz.getDescripcion());
                            fBD.setsInstitucionEducativa(formInterfaz.getInstitucion());
                            fBD.setsPromedio(formInterfaz.getPromedio());
                            fBD.setsTituloRecibido(formInterfaz.getTitulo());
                            fBD.save();
                        }
                    }
                }
            }

            //Borramos las entradas que estan en la base pero no en la interfaz
            for (Formacion fBD : formacionesBD) {
                boolean seDebeBorrar = true;
                for (formacionBean formInterfaz : getFormaciones()) {
                    if (fBD.getIdFormacion() == Integer.valueOf(formInterfaz.getFormacionId())) {
                        seDebeBorrar = false;
                    }
                }
                if (seDebeBorrar) {
                    fBD.delete();
                }
            }

            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO,
                    "Éxito.",
                    "Su información se encuentra al día."));
            //con.close();
            return "";
        } catch (appException ex) {
            Logger.getLogger(AlumnoActionListener.class.getName()).log(Level.SEVERE, null, ex);
            return "";
        }
    }

    /**
     * Guarda los cambios en las citas de investigación Crear, Actualizar y
     * Borrar
     *
     * @return
     */
    public String guardarInvestigacion() {
        try {

            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO,
                    "Se guardará su experiencia en Investigación de acuerdo a su información. ",
                    "En proceso ..."));
            //Conexion con = new Conexion();
            Investigaciones invClass = new Investigaciones(getAlumnoId());
            LinkedList<Investigacion> investigaciones = invClass.getInvestigaciones();
            for (investigacionBean invInterfaz : getInvestigaciones()) {
                if (invInterfaz.getInvestigacionId().compareTo("-1") == 0) {
                    Investigacion a = new Investigacion(-1, getCvId(), invInterfaz.getCita());
                    a.save();
                    //Actualizamos el identificador en la interfaz
                    invInterfaz.setInvestigacionId(String.valueOf(a.getnIdInvestigacion()));
                } else {//Actualizammos las investigaciones existentes
                    for (Investigacion invBD : investigaciones) {
                        if (invBD.getnIdInvestigacion() == Integer.valueOf(invInterfaz.getInvestigacionId())) {
                            invBD.setsReferenciaArticulo(invInterfaz.getCita());
                            invBD.save();
                        }
                    }
                }
            }

            //Borramos las investigaciones que estan en la base pero no en la interfaz
            for (Investigacion invBD : investigaciones) {
                boolean seDebeBorrar = true;
                for (investigacionBean invInterfaz : getInvestigaciones()) {
                    if (invBD.getnIdInvestigacion() == Integer.valueOf(invInterfaz.getInvestigacionId())) {
                        seDebeBorrar = false;
                    }
                }
                if (seDebeBorrar) {
                    invBD.delete();
                }
            }

            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO,
                    "Éxito.",
                    "Su información se encuentra al día."));
            //con.close();
            return "";
        } catch (appException ex) {
            Logger.getLogger(AlumnoActionListener.class.getName()).log(Level.SEVERE, null, ex);
            return "";
        }
    }

    /**
     * Busca las vacantes que vayan acorde con un criterio de búsqueda en la
     * base de datos
     *
     * @return
     */
    public String buscarVacantes() {
        try {
            Conexion con = new Conexion();

            String query = "select isActivado(" + getAlumnoId() + ");";
            ResultSet r = con.exec(query);

            r.next();

            boolean activado = r.getBoolean("isactivado");

            if (!activado) {
                FacesContext.getCurrentInstance().addMessage(null,
                        new FacesMessage(FacesMessage.SEVERITY_ERROR,
                        "Error de Autenticación",
                        "No se pueden buscar las vacantes sin antes completar el curriculum vitae"));
                return "";
            }


            LinkedList<app.empresa.Vacante> vacantesBD = Busqueda.buscaVacantesCon(getDescripcionVacBus());
            getVacantesBuscadas().clear();
            for (app.empresa.Vacante vacBD : vacantesBD) {
                VacanteBean tmp = new VacanteBean();
                tmp.setId(String.valueOf(vacBD.getnIdVacante()));
                tmp.setTitulo(vacBD.getsTituloVacante());
                tmp.setDescripcion(vacBD.getsDescripcion());
                tmp.setHtmlDescripcion(vacBD.getHtmlVacante());
                getVacantesBuscadas().add(tmp);
            }

            con.close();
            return "";
        } catch (SQLException ex) {
            Logger.getLogger(AlumnoActionListener.class.getName()).log(Level.SEVERE, null, ex);
            return "";
        } catch (appException ex) {
            Logger.getLogger(AlumnoActionListener.class.getName()).log(Level.SEVERE, null, ex);
            return "";
        } catch (ConexionException ex) {
            Logger.getLogger(AlumnoActionListener.class.getName()).log(Level.SEVERE, null, ex);
            return "";
        }
    }

    /**
     * Busca las vacantes que vayan acorde con un criterio de búsqueda en la
     * base de datos
     *
     * @return
     */
    public String buscarVacantesAvanzada() {
        try {
            Conexion con = new Conexion();

            String query = "select isActivado(" + getAlumnoId() + ");";
            ResultSet r = con.exec(query);

            r.next();

            boolean activado = r.getBoolean("isactivado");

            if (!activado) {
                FacesContext.getCurrentInstance().addMessage(null,
                        new FacesMessage(FacesMessage.SEVERITY_ERROR,
                        "Error de Autenticación",
                        "No se pueden buscar las vacantes sin antes completar el curriculum vitae"));
                return "";
            }


            LinkedList<app.empresa.Vacante> vacantesBD = Busqueda.buscaVacantesConA(getDescripcionVacBus(), getLatitud(), getLongitud(), getRadioBusqueda());
            getVacantesBuscadas().clear();
            for (app.empresa.Vacante vacBD : vacantesBD) {
                VacanteBean tmp = new VacanteBean();
                tmp.setId(String.valueOf(vacBD.getnIdVacante()));
                tmp.setTitulo(vacBD.getsTituloVacante());
                tmp.setDescripcion(vacBD.getsDescripcion());
                tmp.setHtmlDescripcion(vacBD.getHtmlVacante());
                tmp.setDistanciaMax(vacBD.getDistanciaMax());
                getVacantesBuscadas().add(tmp);
            }

            con.close();
            return "";
        } catch (SQLException ex) {
            Logger.getLogger(AlumnoActionListener.class.getName()).log(Level.SEVERE, null, ex);
            return "";
        } catch (appException ex) {
            Logger.getLogger(AlumnoActionListener.class.getName()).log(Level.SEVERE, null, ex);
            return "";
        } catch (ConexionException ex) {
            Logger.getLogger(AlumnoActionListener.class.getName()).log(Level.SEVERE, null, ex);
            return "";
        }
    }

    /**
     * Postula el alumno a una vacante
     *
     * @return
     * @throws appException
     */
    public String postularVacante() {

        try {




            String idvac = getVacanteSeleccionada().getId();
            //Conexion con = new Conexion();

            //Revisamos que no se haya postulado previamente
            if (Postulados.isPostulado(getAlumnoId(), Integer.valueOf(idvac)) == false) {
                FacesContext.getCurrentInstance().addMessage(null,
                        new FacesMessage(FacesMessage.SEVERITY_INFO,
                        "Se procederá a postular su CV a la Vacante. ",
                        "En proceso ..."));

                Postulados.postulaAlumno(getAlumnoId(), Integer.valueOf(idvac));

            } else {

                FacesContext.getCurrentInstance().addMessage(null,
                        new FacesMessage(FacesMessage.SEVERITY_WARN,
                        "Ya se encuentra postulado a esta vacante.",
                        "Puede revisar esto en la sección de sus postulaciones."));
                return "";
            }
            //Actualizamos las postulaciones del alumno no importa si ya esta o no 
            //postulado
            AlumnoE alumno = new AlumnoE(getAlumnoId());
            LinkedList<Vacante> vacantes = alumno.getMisVacantes();

            getMisPostulaciones().clear();

            for (Vacante v : vacantes) {

                VacanteBean vb = new VacanteBean();

                vb.setTitulo(v.getsTituloVacante());
                vb.setId("" + v.getnIdVacante());
                vb.setDescripcion(v.getsDescripcion());
                vb.setHtmlDescripcion(v.getHtmlVacante());


                getMisPostulaciones().add(vb);
            }
            //con.close();


            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO,
                    "Se postuló con éxito. ",
                    "Puede seguir navegando en las ofertas disponibles o bien verificar sus postulaciones."));
            return "";
        } catch (appException ex) {
            Logger.getLogger(AlumnoActionListener.class.getName()).log(Level.SEVERE, null, ex);
            return "";
        }
    }

    /**
     * Borra la postulación actual. La interfaz se encarga de borrar la
     * postulación
     *
     * @return
     */
    public String borrarPostulacion() {
        try {

            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO,
                    "Se procederá a borrar su postulado. ",
                    "En proceso ..."));

            String idPost = getVacanteSeleccionada().getId();
            //Conexion con = new Conexion();
            Postulados.despostulaAlumno(getAlumnoId(), Integer.valueOf(idPost));
            //con.close();

            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO,
                    "Se borró el postulado correctamente. ",
                    ""));
            return "";
        } catch (appException ex) {
            Logger.getLogger(AlumnoActionListener.class.getName()).log(Level.SEVERE, null, ex);
            return "";
        }
    }
}
